.TH std::rethrow_exception 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::rethrow_exception \- std::rethrow_exception

.SH Synopsis
   Defined in header <exception>
   [[noreturn]] void rethrow_exception( std::exception_ptr p );  \fI(since C++11)\fP

   Throws the previously captured exception object referred-to by the exception pointer
   p, or a copy of that object.

   It is unspecified whether a copy is made. If a copy is made, the storage for it is
   allocated in an unspecified way.

   The behavior is undefined if p is null.

.SH Parameters

   p - non-null std::exception_ptr

.SH Return value

   \fI(none)\fP

.SH Exceptions

   The exception object referred-to by p if no copy is made.

   Otherwise, a copy of such exception object if the implementation successfully copied
   the exception object.

   Otherwise, std::bad_alloc or the exception thrown when copying the exception object,
   if allocation or copying fails, respectively.

.SH Notes

   Before P1675R2, rethrow_exception was not allowed to copy the exception object,
   which is unimplementable on some platforms where exception objects are allocated on
   the stack.

.SH Example



// Run this code

 #include <exception>
 #include <iostream>
 #include <stdexcept>
 #include <string>

 void handle_eptr(std::exception_ptr eptr) // passing by value is ok
 {
     try
     {
         if (eptr)
             std::rethrow_exception(eptr);
     }
     catch(const std::exception& e)
     {
         std::cout << "Caught exception: '" << e.what() << "'\\n";
     }
 }

 int main()
 {
     std::exception_ptr eptr;

     try
     {
         std::string().at(1); // this generates a std::out_of_range
     }
     catch(...)
     {
         eptr = std::current_exception(); // capture
     }

     handle_eptr(eptr);

 } // destructor for std::out_of_range called here, when the eptr is destructed

.SH Possible output:

 Caught exception: 'basic_string::at: __n (which is 1) >= this->size() (which is 0)'

.SH See also

   exception_ptr     shared pointer type for handling exception objects
   \fI(C++11)\fP           \fI(typedef)\fP
   current_exception captures the current exception in a std::exception_ptr
   \fI(C++11)\fP           \fI(function)\fP
